package myArray;
import java.util.Arrays;

public class SequenceList implements ISequenceList{
    //顺序表的实现

    //设置默认数组大小为10
    public static final int DEFAULT = 10;
    public  int[] seqList = new int[DEFAULT];
    public int usedSize = 0;

    //构造方法
    public SequenceList(int capacity) throws MemoryIsEmptyException{
        try {
            if (capacity == 0) {
                //抛异常
                throw new MemoryIsEmptyException("数组内存不能初始化为空！");
            }
        }catch(MemoryIsEmptyException e){
            capacity = DEFAULT;
        }
        seqList = new int[capacity];
    }
    public SequenceList() {
        //默认大小
    }
    //扩容
    private void dilatation() {
        if(checkCapacity()) {
            seqList = Arrays.copyOf(seqList,usedSize*2);
        }
    }
    //尾插
    public void pushBack(int value) {
        //1，检查内存 满则扩容
        dilatation();
        //2，没满 就插入
        this.seqList[this.usedSize] = value;
        //3，usedSize++
        this.usedSize++;
    };
    //头插
    public void pushFront(int value) {
        //1，检查内存 满则扩容
        dilatation();
        //2，没满，直接头插
        for(int i = this.usedSize-1; i >= 0; i--) {
            this.seqList[i+1] = this.seqList[i];
        }
        this.seqList[0] = value;
        this.usedSize++;
    };
    //pos之前位置插入
    public void insert(int pos, int value) throws ArrayIndexOutOfBoundsException{
        //1：对pos进行判定，若是pos不合法，抛出异常
        try{
            if(pos<0 || pos>this.usedSize) {
                throw new ArrayOutOfBoundsException("pos索引非法");
            }
        }catch(ArrayOutOfBoundsException e) {
            //若是pos不合法，直接return结束程序
            return;
        }
        //2：检查内存
        dilatation();
        //3：若是合法，后移，插入
        for(int i = this.usedSize; i>pos; i--) {
            this.seqList[i] = this.seqList[i-1];
        }
        this.seqList[pos] = value;
        this.usedSize++;
    };
    //尾删
    public void popBack() {
        //1:检查有效元素是否为空
        if(checkUsedSize()){
            return;
        }
        //2：删除操作
        this.usedSize--;
    };
    //头删
    public void popFront() {
        //1:检查有效元素是否为空
        if(checkUsedSize()){
            return;
        }
        //2：往前覆盖
        for(int i = 0; i < this.usedSize-1; i++) {
            this.seqList[i] = this.seqList[i+1];
        }
        //3：usedSize--
        this.usedSize--;
    };
    //删除pos位置数据
    public void erase(int pos) {
        //1：检查pos合法性
        try{
            if(pos<0 || pos>=this.usedSize) {
                throw new ArrayOutOfBoundsException("pos索引非法");
            }
        }catch(ArrayOutOfBoundsException e) {
            //若是pos不合法，直接return结束程序
            return;
        }
        //2：删除
        for(int i = pos; i < this.usedSize-1; i++) {
            this.seqList[i] = this.seqList[i+1];
        }
        //3：usedSize--
        this.usedSize--;
    };
    //查找某个数据的下标
    public int indexOf(int toFind) {
        //1:检查有效元素是否为空
        if(checkUsedSize()){
            return-1;
        }
        //2：查找
        for(int i = 0; i < this.usedSize; i++) {
            if(this.seqList[i]==toFind) {
                return i;
            }
        }
        return -1;
    };
    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        //1:检查有效元素是否为空
        if(checkUsedSize()){
            return false;
        }
        //2：遍历
        for(int i = 0; i < this.usedSize; i++) {
            if(this.seqList[i]==toFind) {
                return true;
            }
        }
        return false;
    };

    //获取顺序表的长度
    public int getUsedSize() {
        return this.usedSize;
    };

    //打印顺序表
    public void display() {
        for(int i = 0; i < this.usedSize; i++) {
            System.out.print(this.seqList[i]+" ");
        }
        System.out.println();
    };

    //检查内存空间，判断是否需要扩容
    private boolean checkCapacity() {
        //当数组长度==有效元素个数时，需要扩容
        return this.seqList.length==this.usedSize;
    };

    //检查顺序表中的有效元素个数是否为空
    private boolean checkUsedSize() {
        try{
            //1：判空
            if(this.usedSize==0) {
                throw new MemoryIsEmptyException("顺序表为空！");
            }
        }catch(MemoryIsEmptyException e) {
            return true;
        }
        return false;
    }
}
